package io.github.echarts.render.series;

import io.github.echarts.model.SeriesModel;
import io.github.echarts.model.series.SeriesDataManager;
import io.github.echarts.render.GraphicsRenderer;
import io.github.echarts.render.RenderContext;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 系列渲染协调器
 * 负责协调系列数据的渲染，将渲染逻辑与数据管理分离
 */
public class SeriesRenderingCoordinator {
    
    /** 系列数据管理器 */
    private SeriesDataManager dataManager;
    
    /** 系列渲染器映射，按系列类型存储对应的渲染器 */
    private Map<String, SeriesRenderer> renderers;
    
    /** 渲染上下文 */
    private RenderContext renderContext;
    
    /**
     * 创建系列渲染协调器
     *
     * @param dataManager 系列数据管理器
     */
    public SeriesRenderingCoordinator(SeriesDataManager dataManager) {
        this.dataManager = dataManager;
        this.renderers = new HashMap<>();
        initializeRenderers();
    }
    
    /**
     * 初始化各类型系列的渲染器
     */
    private void initializeRenderers() {
        // 注册各种图表类型的渲染器
        renderers.put("bar", new BarSeriesRenderer());
        // 其他类型的渲染器待添加
    }
    
    /**
     * 设置渲染上下文
     * 
     * @param renderContext 渲染上下文
     */
    public void setRenderContext(RenderContext renderContext) {
        this.renderContext = renderContext;
        
        // 将渲染上下文传递给各个渲染器
        for (SeriesRenderer renderer : renderers.values()) {
            if (renderer instanceof BarSeriesRenderer) {
                ((BarSeriesRenderer) renderer).setRenderContext(renderContext);
            }
        }
    }
    
    /**
     * 渲染所有系列
     *
     * @param renderer 图形渲染器
     */
    public void renderSeries(GraphicsRenderer renderer) {
        // 获取所有系列模型
        List<SeriesModel> allSeries = dataManager.getSeriesModels();
        
        // 确定渲染顺序
        List<SeriesModel> orderedSeries = determineRenderingOrder(allSeries);
        
        // 按顺序渲染每个系列
        for (SeriesModel series : orderedSeries) {
            renderSingleSeries(series, renderer);
        }
    }
    
    /**
     * 确定系列的渲染顺序
     * 
     * @param seriesList 系列模型列表
     * @return 排序后的系列模型列表
     */
    private List<SeriesModel> determineRenderingOrder(List<SeriesModel> seriesList) {
        if (seriesList == null || seriesList.isEmpty()) {
            return Collections.emptyList();
        }
        
        // 复制列表，避免修改原始数据
        List<SeriesModel> ordered = new ArrayList<>(seriesList);
        
        // 根据z轴层级和系列索引排序
        Collections.sort(ordered, new Comparator<SeriesModel>() {
            @Override
            public int compare(SeriesModel s1, SeriesModel s2) {
                // 首先按z轴层级排序
                int z1 = s1.getZLevel();
                int z2 = s2.getZLevel();
                if (z1 != z2) {
                    return z1 - z2;
                }
                
                // z轴相同则按系列索引排序
                return s1.getSeriesIndex() - s2.getSeriesIndex();
            }
        });
        
        return ordered;
    }
    
    /**
     * 渲染单个系列
     *
     * @param series 系列模型
     * @param renderer 图形渲染器
     */
    private void renderSingleSeries(SeriesModel series, GraphicsRenderer renderer) {
        // 获取系列类型对应的渲染器
        String seriesType = series.getType();
        SeriesRenderer seriesRenderer = getSeriesRendererForType(seriesType);
        
        if (seriesRenderer != null) {
            // 使用渲染器渲染系列
            seriesRenderer.render(series, renderer);
        }
    }
    
    /**
     * 获取指定类型的系列渲染器
     *
     * @param type 系列类型
     * @return 系列渲染器
     */
    private SeriesRenderer getSeriesRendererForType(String type) {
        // 获取已注册的渲染器
        SeriesRenderer renderer = renderers.get(type);
        
        // 如果没有找到对应类型的渲染器，使用默认渲染器
        if (renderer == null && type != null) {
            // 记录日志：未找到类型为{type}的渲染器，使用默认渲染器
        }
        
        return renderer;
    }
} 